Automated software development with XML and the Java* language

April–June 2000 Copyright 2000. Lucent Technologies Inc. All rights reserved. Introduction High-level languages and compilers are a great success story of software engineering. One way of understanding this success is to see high-level languages as allowing a division of labor between problemdomain expertise, held by the application developer, and implementation expertise, held by the compiler developer. With domain-specific languages (DSLs),1 this division is magnified. A language is created specifically for an application domain, where requirements for a product in the domain can be precisely and succinctly captured. A compiler for this language then generates the product code directly from the requirements. The developers of a DSL and its compiler are sometimes called domain engineers, while the writers of requirements in the DSL are called application engineers. As an approach to automating software engineering, DSLs have many fascinating aspects. For example, a DSL compiler can be regarded as a formalization of the design of a family of products. Once the design is explicit and formal, the presence of design problems, inconsistencies, and complexity is apparent. Furthermore, design improvements can be implemented as changes to the DSL compiler, allowing the improvements to be applied consistently to all product instances. DSLs are not as widely used as they might be because the return on investment for DSLs is not always clear. Designing a DSL and implementing a DSL compiler are expensive and time consuming, and they also require specialized skills. For example, just the work of analyzing an application domain prior to DSL design (called domain analysis) can require a team of domain experts and considerable time. Training developers to use a new language is costly. Furthermore, if the design approach for an application domain is not well known and stable, the DSL and compiler may require continual enhancement. In this paper, we describe a lightweight approach to DSL-based development using Extensible Markup Language (XML) and the Java* language. Briefly, the idea is to define a DSL as an XML dialect and then to build the DSL compiler using the Java language and existing XML tools. While XML dialects can be verbose, they are suitable for DSLs because they are easy to define and to read. This ease of reading XML dialects stems partly from their similarity to the Hypertext Markup Language (HTML) and partly from ♦ Automated Software Development with XML and the Java* Language Glenn R. Bruns, Alan E. Frey, Peter A. Mataga, and Susan J. Tripp